home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Games / MAME / src / vidhrdw / starfire.c < prev    next >
C/C++ Source or Header  |  2000-04-04  |  7KB  |  297 lines
  1. /***************************************************************************
  2.  
  3.   vidhrdw.c
  4.  
  5.   Functions to emulate the video hardware of the machine.
  6.  
  7. ***************************************************************************/
  8.  
  9. #include "driver.h"
  10. #include "vidhrdw/generic.h"
  11.  
  12. unsigned char starfire_vidctrl;
  13. unsigned char starfire_vidctrl1;
  14. unsigned char *starfire_videoram;
  15. unsigned char *starfire_colorram;
  16. unsigned char starfire_color = 0;
  17.  
  18. WRITE_HANDLER( starfire_vidctrl_w ) {
  19.     starfire_vidctrl = data;
  20. }
  21.  
  22. WRITE_HANDLER( starfire_vidctrl1_w ) {
  23.     starfire_vidctrl1 = data;
  24. }
  25.  
  26. WRITE_HANDLER( starfire_colorram_w ){
  27.     starfire_color = data & 0x1f;
  28.  
  29.     if ((offset & 0xE0) == 0) {
  30.     int r,g,b;
  31.     int d1 = offset & 0x100;
  32.  
  33.     starfire_colorram[offset & 0xfeff] = data;
  34.  
  35.     if (starfire_vidctrl1&0x40) {
  36.     int reg = offset & 0x1f;
  37.         if (offset & 0x200)
  38.         reg |= 0x20;
  39.  
  40.         r = (data & 0x03)*0x49;
  41.         if (d1)
  42.         r |= 0x24;
  43.  
  44.         b = ((data & 0x1c)*0x49) >> 3;
  45.         g = ((data & 0xe0)*0x49) >> 6;
  46.  
  47.         palette_change_color(reg,r,g,b);
  48.     }
  49.     } else
  50.     if(!(starfire_vidctrl1 & 0x80))
  51.         starfire_colorram[offset] = data & 0x1f;
  52. }
  53.  
  54. READ_HANDLER( starfire_colorram_r ) {
  55.     if ((offset & 0xE0) == 0)
  56.     return starfire_colorram[offset&0xfeff];
  57.     else
  58.     return starfire_colorram[offset];
  59. }
  60.  
  61. WRITE_HANDLER( starfire_videoram_w ) {
  62.  
  63.     int i, d0, d1, m0, m1, v0, v1;
  64.     unsigned char c,d,d2;
  65.     int offset2 = (offset+0x100)&0x1fff;
  66.     int source;
  67.  
  68.     if ((!(offset & 0xE0)) && (!(starfire_vidctrl1 & 0x20)))
  69.         return;
  70.  
  71.     /* Handle selector 6A */
  72.     if (offset & 0x2000) {
  73.         c = starfire_vidctrl;
  74.     source = 1;
  75.     } else {
  76.         c = starfire_vidctrl >> 4;
  77.     source = 0;
  78.     }
  79.  
  80.     offset &= 0x1FFF;
  81.  
  82.     /* Handle mirror bits in 5B-5E */
  83.     d2=0;
  84.     d = data & 0xFF;
  85.     if (c & 0x01) {
  86.     for (i=7; i>-1; i--) {
  87.         d2 = d2 | ((d & 0x80) >> i);
  88.         d = d << 1;
  89.     }
  90.     }
  91.     else
  92.     {d2 = d;}
  93.  
  94.  
  95.     /* Handle shifters 6E,6D */
  96.     i = 8 - ((c & 0x0E) >> 1);
  97.  
  98.     d1 = d2 << i;
  99.     d0 = d1 >> 8;
  100.  
  101.     m1 = 0xff << i;
  102.     m0 = m1 >> 8;
  103.  
  104.     /* Clip depending on roll when falling out of the right of the screen */
  105.     if ((offset & 0x1f00) == 0x1f00) {
  106.         if (starfire_vidctrl1 & 0x10)
  107.             m0 = 0;
  108.         else
  109.         m1 = 0;
  110.     }
  111.     v0 = starfire_videoram[offset];
  112.     v1 = starfire_videoram[offset2];
  113.  
  114.     /* Handle ALU 8B,8D */
  115.     switch (starfire_vidctrl1 & 0x0F) {
  116.     case 0:
  117.     v0 = (v0 & ~m0) | (d0 & m0);
  118.     v1 = (v1 & ~m1) | (d1 & m1);
  119.     break;
  120.     case 1:
  121.     v0 = v0 | (d0 & m0);
  122.     v1 = v1 | (d1 & m1);
  123.     break;
  124.     case 2:
  125.     v0 = (v0 ^ m0) | (d0 & m0);
  126.     v1 = (v1 ^ m1) | (d1 & m1);
  127.     break;
  128.     case 3:
  129.     v0 = v0 | m0;
  130.     v1 = v1 | m1;
  131.     break;
  132.     case 4:
  133.     v0 = v0 & (d0 | ~m0);
  134.     v1 = v1 & (d1 | ~m1);
  135.     break;
  136.     case 5:
  137.     break;
  138.     case 6:
  139.     v0 = v0 ^ (d0 & m0) ^ m0;
  140.     v1 = v1 ^ (d1 & m1) ^ m1;
  141.     break;
  142.     case 7:
  143.     v0 = v0 | (~d0 & m0);
  144.     v1 = v1 | (~d1 & m1);
  145.     break;
  146.     case 8:
  147.     v0 = (v0 & ~m0) | (~v0 & d0 & m0);
  148.     v1 = (v1 & ~m1) | (~v1 & d1 & m1);
  149.     break;
  150.     case 9:
  151.     v0 = v0 ^ (d0 & m0);
  152.     v1 = v1 ^ (d1 & m1);
  153.     break;
  154.     case 10:
  155.     v0 = v0 ^ m0;
  156.     v1 = v1 ^ m1;
  157.     break;
  158.     case 11:
  159.     v0 = (v0 & ~m0) | (~(v0 & d0) & m0);
  160.     v1 = (v1 & ~m1) | (~(v1 & d1) & m1);
  161.     break;
  162.     case 12:
  163.     v0 = v0 & ~m0;
  164.     v1 = v1 & ~m1;
  165.     break;
  166.     case 13:
  167.     v0 = v0 & ~(d0 & m0);
  168.     v1 = v1 & ~(d1 & m1);
  169.     break;
  170.     case 14:
  171.     v0 = (v0 & ~m0) | (~(v0 | d0) & m0);
  172.     v1 = (v1 & ~m1) | (~(v1 | d1) & m1);
  173.     break;
  174.     case 15:
  175.     v0 = (v0 & ~m0) | (~d0 & m0);
  176.     v1 = (v1 & ~m1) | (~d1 & m1);
  177.     break;
  178.     }
  179.  
  180.     starfire_videoram[offset] = v0;
  181.     starfire_videoram[offset2] = v1;
  182.  
  183.     if (!source && !(starfire_vidctrl1 & 0x80)) {
  184.     if(m0)
  185.         starfire_colorram[offset] = starfire_color;
  186.     if(m1)
  187.         starfire_colorram[offset2] = starfire_color;
  188.     }
  189. }
  190.  
  191. READ_HANDLER( starfire_videoram_r )
  192. {
  193.     int i, m0, m1, d0;
  194.     unsigned char c;
  195.     int offset2 = (offset+0x100)&0x1fff;
  196.  
  197.     /* Handle selector 6A */
  198.     if (offset & 0x2000)
  199.         c = starfire_vidctrl;
  200.     else
  201.         c = starfire_vidctrl >> 4;
  202.  
  203.     offset &= 0x1FFF;
  204.  
  205.     /* Handle shifter mask 6E,6D */
  206.     i = 8 - ((c & 0x0E) >> 1);
  207.  
  208.     m1 = 0xff << i;
  209.     m0 = m1 >> 8;
  210.  
  211.     /* Clip depending on roll when falling out of the right of the screen */
  212.     if ((offset & 0x1f00) == 0x1f00) {
  213.         if (starfire_vidctrl1 & 0x10)
  214.             m0 = 0;
  215.         else
  216.         m1 = 0;
  217.     }
  218.     d0 = (starfire_videoram[offset] & m0 ) | (starfire_videoram[offset2] & m1);
  219.  
  220.     d0 = ((d0 >> i) | (d0 << (8-i))) & 0xff;
  221.  
  222.     return d0;
  223. }
  224.  
  225.  
  226. /***************************************************************************
  227.  
  228.   Draw the game screen in the given osd_bitmap.
  229.   Do NOT call osd_update_display() from this function, it will be called by
  230.   the main emulation engine.
  231.  
  232. ***************************************************************************/
  233. void starfire_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
  234. {
  235.         int x,y,xx;
  236.         int j,col;
  237.         long pnt;
  238.         int d;
  239.  
  240.         palette_recalc();
  241.  
  242.         pnt = 0x0000;
  243.         xx=0;
  244.  
  245.         for (x=0; x<32; x++) {
  246.             for (y=0; y<256; y++) {
  247.                 d= starfire_videoram[pnt];
  248.                 col = starfire_colorram[pnt++];
  249.                 for (j=0; j<8; j++) {
  250.                     if (d & 0x80)
  251.                         tmpbitmap->line[y][xx+j] = Machine->pens[col+32];
  252.                     else
  253.                         tmpbitmap->line[y][xx+j] = Machine->pens[col];
  254.                     d = d << 1;
  255.                 }
  256.             }
  257.             xx=xx+8;
  258.         pnt+=0x00;
  259.        }
  260.        copybitmap(bitmap,tmpbitmap,0,0,0,0,&Machine->drv->visible_area,TRANSPARENCY_NONE,0);
  261. }
  262.  
  263. int starfire_vh_start(void)
  264. {
  265.     int i;
  266.  
  267.     if ((tmpbitmap = osd_create_bitmap(Machine->drv->screen_width,Machine->drv->screen_height)) == 0)
  268.         return 1;
  269.  
  270.     if ((starfire_videoram = malloc(0x2000)) == 0)
  271.     {
  272.         osd_free_bitmap(tmpbitmap);
  273.         return 1;
  274.     }
  275.     if ((starfire_colorram = malloc(0x2000)) == 0)
  276.     {
  277.         osd_free_bitmap(tmpbitmap);
  278.         free(starfire_videoram);
  279.         return 1;
  280.     }
  281.  
  282.     for (i=0; i<0x2000; i++) {
  283.         starfire_videoram[i]=0;
  284.         starfire_colorram[i]=0;
  285.     }
  286.  
  287.     return 0;
  288. }
  289.  
  290. void starfire_vh_stop(void)
  291. {
  292.     osd_free_bitmap(tmpbitmap);
  293.     free(starfire_videoram);
  294.     free(starfire_colorram);
  295. }
  296.  
  297.